package BakaNoPackage.Donnees;

import java.util.*;
import java.sql.*;

import BakaNoPackage.Exception.*;

public class Donnees {

	//tableau pour les tables et champs de la base de données
	private static final String[] t_table	= {"serie","saison","entite","episode","tome"};
	private static final String[] t_serie   = {"id","nom","evaluation","commentaire","synopsis","dateSortie"};
	private static final String[] t_saison  = {"id","idSerie","nom","evaluation","commentaire","synopsis","dateSortie"};
	private static final String[] t_entite  = {"id","idSaison","nom","synopsis"};
	private static final String[] t_episode = {"idEntite","duree"};
	private static final String[] t_tome    = {"idEntite","nombrePage"};
	
	String driver = "org.apache.derby.jdbc.EmbeddedDriver";
	String dbName;
	
	Connection connexion;
    
    /**
     * 
     * @param dbName
     * @throws Exception
     */
	public Donnees(String dbName) throws Exception{
		//On charge le driver
		Class.forName(driver);
		
		connexion(dbName);
		//Manga m = this.getManga("test");
		//Saison s = this.getSaison(m.getID(), "s2");
		//Entite[] es= this.getEntites(s.getID());
		//System.out.println(es.length);
		//this.getEntite(s.getID(), "e1");
	}
	
	/**
	 * permet de recuperer tous les mangas de la base de données
	 * @return un tableau de tous les mangas de la BDD
	 * @throws MangaIntrouvableException
	 */
	public Manga[] getMangas(){
		LinkedList<Manga> mangas = new LinkedList<Manga>(); 
		ResultSet result;

		//recuperer tous les mangas dans la bdd
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[0]);
			while (result.next())
				mangas.add(new Manga(result.getInt(1),result.getString(2),result.getString(4),result.getString(5),result.getDate(6),result.getInt(3), this));
			
			return mangas.toArray(new Manga[0]);
		}catch(SQLException e){System.out.println(e.getMessage()); return null;}
	}
	
	/**
	 * permet de récuperer le manga correspondant au nom dans la BDD
	 * @param nom le nom du manga
	 * @return le manga
	 * @throws MangaIntrouvableException
	 */
	public Manga getManga(String nom) throws MangaIntrouvableException{
		ResultSet result;
		
		//recuperer le manga dans la bdd
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[0]+" WHERE "+t_serie[1]+"='"+parseString(nom)+"'");
			if (!result.next())//s'il n'a rien trouvé, on lance l'exception
				throw new MangaIntrouvableException("Le manga "+nom+" n'est pas dans la base de donnees");
			return new Manga(result.getInt(1),result.getString(2),result.getString(4),result.getString(5),result.getDate(6),result.getInt(3), this);
		}catch(SQLException e){System.out.println(e); return null;}
	}
	
	/**
	 * permet de modifier un manga dans la BDD
	 * @param manga le manga à modifier
	 * @throws MangaIntrouvableException
	 */
	public void setManga(Manga manga) throws MangaIntrouvableException{
		ResultSet result;
		//recuperer le manga dans la bdd
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[0]+" WHERE "+t_serie[0]+"="+manga.getID());
			if (!result.next())//s'il n'a rien trouvé, on lance l'exception
				throw new MangaIntrouvableException("Le manga "+manga.getNom()+" n'est pas dans la base de donnees");
			String date= (manga.getDateSortie().getYear()+1900)+"-"+(manga.getDateSortie().getMonth()+1)+"-"+manga.getDateSortie().getDate();
			this.connexion.createStatement().executeUpdate("UPDATE "+t_table[0]+
					" SET "+t_serie[1]+" = '"+parseString(manga.getNom())+"' , "+
							t_serie[2]+" = "+manga.getEvaluation()+" , "+
							t_serie[3]+" = '"+parseString(manga.getCommentaire())+"' , "+
							t_serie[4]+" = '"+parseString(manga.getSynopsis())+"' , "+
							t_serie[5]+" = '"+date+"'"+
							" WHERE "+t_serie[0]+" = "+manga.getID());
		}catch(SQLException e){System.out.println(e);}
	}
	
	/**
	 * permet de supprimer un manga de la base de données
	 * @param manga le manga
	 * @throws MangaIntrouvableException
	 */
	public void deleteManga(Manga manga) throws MangaIntrouvableException{
		//supprime toutes les saisons du manga
		
		Saison[] s = manga.getSaisons();
		if (s!=null)
			for (int i=0;i<s.length;i++)
				try{
					this.deleteSaison(s[i]);
				}catch(SaisonIntrouvableException ex) {
					throw new MangaIntrouvableException("La saison "+s[i].getNom()+
					  " du manga "+manga.getNom()+" n'est pas dans la base de données");
				}
		
		ResultSet result;
		//recuperer le manga dans la bdd
		try{
			result = this.connexion.createStatement().executeQuery(
					"SELECT * FROM "+t_table[0]+" WHERE "+t_serie[0]+"="+manga.getID());
			if (!result.next())//s'il n'a rien trouvé, on lance l'exception
				throw new MangaIntrouvableException("Le manga "+manga.getNom()+" n'est pas dans la base de donnees");
			this.connexion.createStatement().executeUpdate(
					"DELETE FROM "+t_table[0]+" WHERE "+t_serie[0]+" = "+manga.getID());
		}catch(SQLException e){System.out.println(e);}
		
	}
	
	/**
	 * permet de créer un nouveau manga dans la BDD
	 * @param nom le nom du manga
	 * @return le manga 
	 * @throws MangaExistantException
	 */
	public Manga createManga(String nom) throws MangaExistantException{
		//creation du manga dans la db
		nom=parseString(nom);
		try{
			ResultSet result = connexion.createStatement().executeQuery(
					"SELECT "+t_serie[0]+", "+t_serie[1]+" FROM "+t_table[0]+" WHERE "+t_serie[1]+"='"+nom+"'");
			//si le manga est deja existant
			if (result.next())
				throw new MangaExistantException();
			
			//insère le manga dans la BDD
			connexion.createStatement().executeUpdate(
					"INSERT INTO "+t_table[0]+" ("+t_serie[1]+" ) VALUES ('"+nom+"')");
			result = connexion.createStatement().executeQuery(
					"SELECT "+t_serie[0]+", "+t_serie[1]+" FROM "+t_table[0]+" WHERE "+t_serie[1]+"='"+nom+"'");
			result.next();//pour pouvoir récupèrer la première ligne
			return new Manga(result.getInt(1),result.getString(2),"","",null,0, this);
		}catch(SQLException e){System.out.println(e); return null;}
	}
	
	private String parseString(String s){
		String[] temp = s.split("\'");
		String t = new String();
		System.out.println(temp.length);
		for (int i=0;i<temp.length;i++)
			if (i!=temp.length-1)
				t+=temp[i]+"''";
			else
				t+=temp[i];
		if (s.endsWith("\'"))
			t+="''";
		return t;
	}
	
	/**
	 * permet de récupérer les saisons lié à un manga
	 * @param manga l'id du manga
	 * @return les saisons du manga
	 * @throws MangaIntrouvableException
	 * @throws SaisonIntrouvableException
	 */
	public Saison[] getSaisons(int manga) throws MangaIntrouvableException, SaisonIntrouvableException {
		LinkedList<Saison> saisons = new LinkedList<Saison>();
		boolean modif = false;
		
		if(!mangaExiste(manga))//si le manga n'existe pas, on lance l'exception
			throw new MangaIntrouvableException("Le manga avec l'id "+manga+" n'est pas dans la base de donnees");
		//recupere les saisons d'un manga dans la db
		try{
			ResultSet result = connexion.createStatement().executeQuery(
					"SELECT * FROM "+t_table[1]+" WHERE "+t_saison[1]+"="+manga);
			
			while (result.next()){
				saisons.add(new Saison(result.getInt(1), result.getString(3), result.getString(5),
							result.getString(6), result.getDate(7), result.getInt(4), this));
				modif=true;
			}
			
			if (modif)//si le manga ne contient pas de saison, on lance une exception
				return saisons.toArray(new Saison[0]);
			else
				throw new SaisonIntrouvableException("Le manga avec l'id "+manga+" n'a pas de saison");
		}catch(SQLException e){System.out.println(e); return null;}
	}
	
	/**
	 * permet de récupère une saison d'un manga dans la BDD
	 * @param manga l'id du manga
	 * @param nom le nom de la saison a récupérer
	 * @return la saison
	 * @throws MangaIntrouvableException
	 * @throws SaisonIntrouvableException
	 */
	public Saison getSaison(int manga, String nom) throws MangaIntrouvableException, SaisonIntrouvableException{
		if(!mangaExiste(manga))
			throw new MangaIntrouvableException("Le manga avec l'id "+manga+" n'est pas dans la base de donnees");
		//recupere la saison nommé 'nom' d'un manga dans la db
		try{
			ResultSet result = connexion.createStatement().executeQuery(
					"SELECT * FROM "+t_table[1]+" WHERE "+t_saison[1]+"="+manga+" AND "+t_saison[2]+"='"+parseString(nom)+"'");
			
			//si la saison existe
			if (result.next())
				return new Saison(result.getInt(1), result.getString(3), result.getString(5),
							result.getString(6), result.getDate(7), result.getInt(4), this);
			else//autrement on lance une exception
				throw new SaisonIntrouvableException("Le manga avec l'id "+manga+" n'a pas de saison");
		}catch(SQLException e){System.out.println(e); return null;}
	}
	
	/**
	 * permet de modifier les paramètre d'une saison dans la BDD
	 * @param saison la saison à modifier
	 * @throws SaisonIntrouvableException
	 */
	public void setSaison (Saison saison) throws SaisonIntrouvableException{
		ResultSet result;
		//recuperer le manga dans la bdd
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[1]+" WHERE "+t_saison[0]+"="+saison.getID());
			if (!result.next())//s'il n'a rien trouvé, on lance l'exception
				throw new SaisonIntrouvableException("Le saison "+saison.getNom()+" n'est pas dans la base de donnees");
			String date= (saison.getDateSortie().getYear()+1900)+"-"+(saison.getDateSortie().getMonth()+1)+"-"+saison.getDateSortie().getDate();
			this.connexion.createStatement().executeUpdate("UPDATE "+t_table[1]+
					" SET "+t_saison[2]+" = '"+parseString(saison.getNom())+"' , "+
							t_saison[3]+" =  "+saison.getEvaluation()+" , "+
							t_saison[4]+" = '"+parseString(saison.getCommentaire())+"' , "+
							t_saison[5]+" = '"+parseString(saison.getSynopsis())+"' , "+
							t_saison[6]+" = '"+date+"'"+
							" WHERE "+t_saison[0]+" = "+saison.getID());
		}catch(SQLException e){System.out.println(e);}
	}
	
	/**
	 * permet de supprimer une saison de la base de données
	 * @param saison la saison
	 * @throws MangaIntrouvableException
	 */
	public void deleteSaison(Saison saison) throws SaisonIntrouvableException{
		//supprime toutes les entites de la saison
		Entite[] e = saison.getEntites();
		if (e!=null)
			for (int i=0; i<e.length;i++)
				try{
					if (e[i] instanceof Episode)
						this.deleteEpisode((Episode)e[i]);
					else
						this.deleteTome((Tome)e[i]);
				}catch(EntiteIntrouvableException ex) {
					throw new SaisonIntrouvableException("L'entite "+e[i].getNom()+
					  " de la saison "+saison.getNom()+" n'est pas dans la base de données");
				}
		 
		ResultSet result;
		//recuperer le manga dans la bdd
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[1]+" WHERE "+t_saison[0]+"="+saison.getID());
			if (!result.next())//s'il n'a rien trouvé, on lance l'exception
				throw new SaisonIntrouvableException("Le saison "+saison.getNom()+" n'est pas dans la base de donnees");
			this.connexion.createStatement().executeUpdate("DELETE FROM "+t_table[1]+" WHERE "+t_saison[0]+" = "+saison.getID());
		}catch(SQLException ex){System.out.println(ex);}
	}
	
	/**
	 * Creation d'une saison dans la base de données
	 * @param manga
	 * @param nom
	 * @return la saison demandée
	 * @throws SaisonExistantException
	 */
	public Saison createSaison(int manga, String nom) throws SaisonExistantException{
		//creation d'une saison dans la db
		nom = parseString(nom);
		try{
			ResultSet result = connexion.createStatement().executeQuery(
					"SELECT "+t_saison[0]+" FROM "+t_table[1]+" WHERE "+t_saison[1]+"="+manga+" AND "+t_saison[2]+"='"+nom+"'");
			//si la saison est deja existante
			if (result.next())
				throw new SaisonExistantException();
			connexion.createStatement().executeUpdate("INSERT INTO "+t_table[1]+" ("+t_saison[1]+", "+t_saison[2]+" )" +
					"										 VALUES ("+manga+", '"+nom+"')");
			result = connexion.createStatement().executeQuery(
					"SELECT "+t_saison[0]+", "+t_saison[2]+" FROM "+t_table[1]+" WHERE "+t_saison[1]+"="+manga+" AND "+t_saison[2]+"='"+nom+"'");
			result.next();//pour pouvoir récupèrer la première ligne
			return new Saison(result.getInt(1), result.getString(2), "", "", null, 0, this);
		}catch(SQLException e){System.out.println(e.getMessage()); return null;}
	}
	
	/**
	 * permet de récupérer les entites d'une saisons
	 * @param saison l'id de la saison
	 * @return toutes les entites de cette saison
	 * @throws SaisonIntrouvableException
	 * @throws EntiteIntrouvableException
	 */
	public Entite[] getEntites(int saison) throws SaisonIntrouvableException, EntiteIntrouvableException{
		LinkedList<Entite> entites = new LinkedList<Entite>();
		boolean modif = false;
		if(!saisonExiste(saison))//si la saison n'existe pas, on lance une exception
			throw new SaisonIntrouvableException("La saison avec l'id "+saison+" n'est pas dans la base de donnees");
		//recupere les entites d'une saisons dans la bdd
		try{
			ResultSet result = connexion.createStatement().executeQuery(
					"SELECT * FROM "+t_table[2]+" WHERE "+t_entite[1]+"="+saison);
			//recupere tous les entites
			while (result.next()){
				//récuperer un episode 
				 ResultSet result2 = connexion.createStatement().executeQuery(
							"SELECT * FROM "+t_table[3]+" WHERE "+t_episode[0]+"="+result.getInt(1));
				 if (!result2.next()){//si on a pas trouvé d'episode on recupere un tome
					 result2 = connexion.createStatement().executeQuery(
								"SELECT * FROM "+t_table[4]+" WHERE "+t_tome[0]+"="+result.getInt(1));
					 if (result2.next())//si on trouve un tome
						  entites.add(new Tome(result.getInt(1), result.getInt(2), result.getString(3), result.getString(4), result2.getInt(2), this));
					 else//autrement lance une exception
						 throw new EntiteIntrouvableException("L'entite avec l'id "+result.getInt(1)+" n'est pas dans la base de donnees");
				 }
				 else
					 entites.add(new Episode(result.getInt(1), result.getInt(2), result.getString(3), result.getString(4), result2.getInt(2), this));
				modif=true;
			}
			if (modif)//si la saison contient des entites
				return entites.toArray(new Entite[0]);
			else//autrement on lance une exception
				throw new EntiteIntrouvableException("La saison avec l'id "+saison+" n'a pas d'episode/tome");
		}catch(SQLException e){System.out.println(e); return null;}
	}
	
	/**
	 * permet de récupérer une entite d'une saison
	 * @param saison l'id de la saison
	 * @param nom le nom de l'entite à récupérer
	 * @return l'entite
	 * @throws SaisonIntrouvableException
	 * @throws EntiteIntrouvableException
	 */
	public Entite getEntite(int saison, String nom) throws SaisonIntrouvableException, EntiteIntrouvableException{
		
		if(!saisonExiste(saison))//si la saison n'existe pas, on lance une exception
			throw new SaisonIntrouvableException("La saison avec l'id "+saison+" n'est pas dans la base de donnees");
		try{
			ResultSet result = connexion.createStatement().executeQuery(
						 "SELECT * FROM "+t_table[2]+" WHERE "+t_entite[1]+"="+saison+" AND "+t_entite[2]+"='"+parseString(nom)+"'");
			
			 if(!result.next())
				 throw new EntiteIntrouvableException("L'entite avec le nom "+nom+" n'existe pas");
			 //récuperer un episode 
			 ResultSet result2 = connexion.createStatement().executeQuery(
						"SELECT * FROM "+t_table[3]+" WHERE "+t_episode[0]+"="+result.getInt(1));
			 
			 if (!result2.next()){//si on a pas trouvé d'episode on recupere un tome
				 result2 = connexion.createStatement().executeQuery(
							"SELECT * FROM "+t_table[4]+" WHERE "+t_tome[0]+"="+result.getInt(1));
				 if (result2.next())//si on trouve un tome
					 return new Tome(result.getInt(1), result.getInt(2), result.getString(3), result.getString(4), result2.getInt(2), this);
				 else//autrement lance une exception
					 throw new EntiteIntrouvableException("La saison avec l'id "+saison+" n'a pas d'episode");
			 }
			 else
				return new Episode(result.getInt(1), result.getInt(2), result.getString(3), result.getString(4), result2.getInt(2), this);
				
		}catch(SQLException e){System.out.println(e); return null;}
	}
	
	/**
	 * permet de créer un tome dans une saison de la la BDD
	 * @param saison l'id de la saison
	 * @param nom le nom du tome à rajouter
	 * @return le tome
	 * @throws EntiteExistantException
	 */
	public Tome createTome(int saison, String nom) throws EntiteExistantException {
		nom=parseString(nom);
		//creation d'un tome dans la bdd
		try{
			ResultSet result = connexion.createStatement().executeQuery(
					"SELECT "+t_entite[0]+" FROM "+t_table[2]+" WHERE "+t_entite[1]+"="+saison+" AND "+t_entite[2]+"='"+nom+"'");
			//si le tome est deja existant, on lance une exception
			if (result.next())
				throw new EntiteExistantException();
			
			//inserer le tome dans la table entite
			connexion.createStatement().executeUpdate("INSERT INTO "+t_table[2]+" ("+t_entite[1]+", "+t_entite[2]+" )" +
														" VALUES ("+saison+", '"+nom+"')");
			result = connexion.createStatement().executeQuery(
					"SELECT "+t_entite[0]+", "+t_entite[1]+", "+t_entite[2]+" FROM "+t_table[2]+" WHERE "+t_entite[1]+"="+saison+" AND "+t_entite[2]+"='"+nom+"'");
			result.next();//pour pouvoir récupèrer la première ligne
			//inserer le tome dans la table tome
			connexion.createStatement().executeUpdate("INSERT INTO "+t_table[4]+" ("+t_tome[0]+", "+t_tome[1]+" )" +
														" VALUES ("+result.getInt(1)+", 0)");
			return new Tome(result.getInt(1), result.getInt(2), result.getString(3), "", 0, this);
		}catch(SQLException e){System.out.println(e); return null;}	
	}
	
	/**
	 * permet de modifier un tome dans la BDD
	 * @param tome le tome à modifier
	 * @throws EntiteIntrouvableException
	 */
	public void setTome (Tome tome) throws EntiteIntrouvableException{
		ResultSet result;
		
		//recuperer le manga dans la bdd
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[2]+" WHERE "+t_entite[0]+"="+tome.getID());
			if (!result.next())//s'il n'a rien trouvé, on lance l'exception
				throw new EntiteIntrouvableException("Le tome "+tome.getNom()+" n'est pas dans la base de donnees");
			//modifie la table entite
			this.connexion.createStatement().executeUpdate("UPDATE "+t_table[2]+
					" SET "+t_entite[1]+" =  "+tome.getIDSaison()+" , "+
							t_entite[2]+" = '"+parseString(tome.getNom())+"' , "+
							t_entite[3]+" = '"+parseString(tome.getSynopsis())+"'"+
							" WHERE "+t_entite[0]+" = "+tome.getID());
			
			//modifie la table tome
			this.connexion.createStatement().executeUpdate("UPDATE "+t_table[4]+
					" SET "+t_tome[1]+" = "+tome.getNbPages()+" WHERE "+t_tome[0]+" = "+tome.getID());
			
		}catch(SQLException e){System.out.println(e);}
	}
	

	/**
	 * permet de supprimer un tome de la base de données
	 * @param tom
	 * @throws EntiteIntrouvableException
	 */
	public void deleteTome(Tome tome) throws EntiteIntrouvableException{
		ResultSet result;
		
		//recuperer le manga dans la bdd
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[2]+" WHERE "+t_entite[0]+"="+tome.getID());
			if (!result.next())//s'il n'a rien trouvé, on lance l'exception
				throw new EntiteIntrouvableException("Le tome "+tome.getNom()+" n'est pas dans la base de donnees");
			//supprime le tome de la table tome
			this.connexion.createStatement().executeUpdate("DELETE FROM "+t_table[4]+" WHERE "+t_tome[0]+" = "+tome.getID());
			//supprimer le tome de la table entite
			this.connexion.createStatement().executeUpdate("DELETE FROM "+t_table[2]+" WHERE "+t_entite[0]+" = "+tome.getID());
		}catch(SQLException e){System.out.println(e.getMessage());}
	}
	
	/**
	 * permet de créer un épisode dans une saison de la BDD
	 * @param saison l'id de la saison
	 * @param nom le nom de l'épisode à rajouter
	 * @return l'épisode
	 * @throws EntiteExistantException
	 */
	public Episode createEpisode(int saison, String nom) throws EntiteExistantException{
		nom = parseString(nom);
		//creation d'un épisode dans la bdd
		
		try{
			ResultSet result = connexion.createStatement().executeQuery(
					"SELECT "+t_entite[0]+" FROM "+t_table[2]+" WHERE "+t_entite[1]+"="+saison+" AND "+t_entite[2]+"='"+nom+"'");
			//si l'épisode est deja existant, on lance une exception
			if (result.next())
				throw new EntiteExistantException();
			
			//inserer l'épisode dans la table entite
			connexion.createStatement().executeUpdate("INSERT INTO "+t_table[2]+" ("+t_entite[1]+", "+t_entite[2]+" )" +
														" VALUES ("+saison+", '"+nom+"')");
			result = connexion.createStatement().executeQuery(
					"SELECT "+t_entite[0]+", "+t_entite[1]+", "+t_entite[2]+" FROM "+t_table[2]+" WHERE "+t_entite[1]+"="+saison+" AND "+t_entite[2]+"='"+nom+"'");
			result.next();//pour pouvoir récupèrer la première ligne
			//inserer l'épisode dans la table episode
			connexion.createStatement().executeUpdate("INSERT INTO "+t_table[3]+" ("+t_episode[0]+", "+t_episode[1]+" )" +
														" VALUES ("+result.getInt(1)+", 0)");
			return new Episode(result.getInt(1), result.getInt(2), result.getString(3), "", 0, this);
		}catch(SQLException e){System.out.println(e.getMessage()); return null;}
	}
	
	/**
	 * permet de modifier un épisode dans la BDD
	 * @param episode l'épisode à modifier
	 * @throws EntiteIntrouvableException
	 */
	public void setEpisode (Episode episode) throws EntiteIntrouvableException{
		
		ResultSet result;
		//recuperer le manga dans la bdd
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[2]+" WHERE "+t_entite[0]+"="+episode.getID());
			if (!result.next())//s'il n'a rien trouvé, on lance l'exception
				throw new EntiteIntrouvableException("L'episode "+episode.getNom()+" n'est pas dans la base de donnees");
			//modifie la table entite
			this.connexion.createStatement().executeUpdate("UPDATE "+t_table[2]+
					" SET "+t_entite[1]+" =  "+episode.getIDSaison()+" , "+
							t_entite[2]+" = '"+parseString(episode.getNom())+"' , "+
							t_entite[3]+" = '"+parseString(episode.getSynopsis())+"'"+
							" WHERE "+t_entite[0]+" = "+episode.getID());
			
			//modifie la table tome
			this.connexion.createStatement().executeUpdate("UPDATE "+t_table[3]+
					" SET "+t_episode[1]+" = "+episode.getDuree()+" WHERE "+t_episode[0]+" = "+episode.getID());
			
		}catch(SQLException e){System.out.println(e);System.out.println("Tome");}
	}
	
	/**
	 * permet de supprimer un episode de la base de données
	 * @param episode
	 * @throws EntiteIntrouvableException
	 */ 
	public void deleteEpisode(Episode episode) throws EntiteIntrouvableException{
		ResultSet result;
		
		//recuperer le manga dans la bdd
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[2]+" WHERE "+t_entite[0]+"="+episode.getID());
			if (!result.next())//s'il n'a rien trouvé, on lance l'exception
				throw new EntiteIntrouvableException("Le tome "+episode.getNom()+" n'est pas dans la base de donnees");
			//supprime le tome de la table episode
			this.connexion.createStatement().executeUpdate("DELETE FROM "+t_table[3]+" WHERE "+t_episode[0]+" = "+episode.getID());
			//supprimer le tome de la table entite
			this.connexion.createStatement().executeUpdate("DELETE FROM "+t_table[2]+" WHERE "+t_entite[0]+" = "+episode.getID());
		}catch(SQLException e){System.out.println(e);}
	}
	
	/**
	 * permet de savoir si un manga existe dans la BDD
	 * @param manga l'id du manga
	 * @return true s'il existe, false sinon
	 */
	private boolean mangaExiste(int manga){
		ResultSet result;
		//recuperer le manga dans la db
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[0]+" WHERE "+t_serie[0]+"="+manga);
			if (result.next())
				return true;
			else 
				return false;
		}catch(SQLException e){System.out.println(e.getMessage()); return false;}
	}
	
	/**
	 * permet de savoir si une saison existe dans la BDD
	 * @param saison l'id de la saison
	 * @return true si elle existe, false sinon
	 */
	private boolean saisonExiste(int saison){
		ResultSet result;
		//recuperer le manga dans la db
		try{
			result = this.connexion.createStatement().executeQuery("SELECT * FROM "+t_table[1]+" WHERE "+t_saison[0]+"="+saison);
			if (result.next())
				return true;
			else 
				return false;
		}catch(SQLException e){System.out.println(e.getMessage()); return false;}
	}
	
	/**
	 * 
	 * @param dbName
	 * @throws Exception
	 */
	public void connexion(String dbName) throws Exception{
		this.dbName = dbName;
		//connexino à la base de données
		connexion = DriverManager.getConnection("jdbc:derby:"+ dbName + ";create=true");
		//Si les tables ne sont pas créées, on les créé ici
		if(!isBaseDonneeValide()){
			this.creerBaseDonnees();
		}
		//System.out.println("BD ok!");
	}
	
	/**
	 * Creation des tables selon le modele
	 * @throws Exception
	 */
	public void creerBaseDonnees() throws Exception{
		//Supprimer les tables de la base de donnees
		for (int i=0; i<t_table.length;i++){
			//si 1ere fois, les tables ne sont pas créer, alors on recupere les 
			//exception pour eviter qu'il plante.
			try{
				this.connexion.createStatement().executeUpdate("DROP TABLE "+t_table[i]);
			}catch(SQLException e){};
		}
		
		//cree les tables de la base de donnee
		this.connexion.createStatement().executeUpdate("CREATE TABLE "+t_table[0]+" (" +
				" "+t_serie[0]+" INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY 	(START WITH 1, INCREMENT BY 1), " + 
				" "+t_serie[1]+" VARCHAR(255) NOT NULL, " +
				" "+t_serie[2]+" INTEGER default NULL, " +
				" "+t_serie[3]+" LONG VARCHAR, " +
				" "+t_serie[4]+" LONG VARCHAR, " +
				" "+t_serie[5]+" DATE default NULL, " +
				" PRIMARY KEY  ("+t_serie[0]+"))");
		
		this.connexion.createStatement().executeUpdate("CREATE TABLE "+t_table[1]+" (" +
				" "+t_saison[0]+" INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1), " +
				" "+t_saison[1]+" INTEGER NOT NULL," +
				" "+t_saison[2]+" VARCHAR(255) NOT NULL," +
				" "+t_saison[3]+" INTEGER default NULL," +
				" "+t_saison[4]+" LONG VARCHAR," +
				" "+t_saison[5]+" LONG VARCHAR," +
				" "+t_saison[6]+" DATE default NULL," +
				" PRIMARY KEY  ("+t_saison[0]+"))");
		
		this.connexion.createStatement().executeUpdate("CREATE TABLE "+t_table[2]+" (" +
				" "+t_entite[0]+" INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1)," +
				" "+t_entite[1]+" INTEGER NOT NULL," +
				" "+t_entite[2]+" VARCHAR(255) NOT NULL," +
				" "+t_entite[3]+" LONG VARCHAR," +
				" PRIMARY KEY  ("+t_entite[0]+"))");
		
		this.connexion.createStatement().executeUpdate("CREATE TABLE "+t_table[3]+" (" +
				" "+t_episode[0]+" INTEGER NOT NULL," +
				" "+t_episode[1]+" INTEGER default NULL)");
		
		this.connexion.createStatement().executeUpdate("CREATE TABLE "+t_table[4]+" (" +
				" "+t_tome[0]+" INTEGER NOT NULL," +
				" "+t_tome[1]+" INTEGER default NULL)");
	}
	
	/**
	 * test si la base de donnees est valide, c'est a dire si les tables
	 * sont crees et correct, avec les bons noms de champs
	 * @return true si valide, false sinon
	 */
	public boolean isBaseDonneeValide(){
		ResultSetMetaData rm;
		
		//test si la table Serie est correct
		try{
			rm = connexion.createStatement().executeQuery("SELECT * FROM "+t_table[0]).getMetaData();
			for(int i=1;i<=rm.getColumnCount();i++)
		  	  	if (t_serie[i-1].equals(rm.getColumnLabel(i)))
		  	  		return false;
		}catch (SQLException e){return false;};
		
		//test si la table Saison est correct
		try{
			rm = connexion.createStatement().executeQuery("SELECT * FROM "+t_table[1]).getMetaData();
			for(int i=1;i<=rm.getColumnCount();i++)
		  	  	if (t_saison[i-1].equals(rm.getColumnLabel(i)))
		  	  		return false;
		}catch (SQLException e){return false;};
		
		//test si la table Entite est correct
		try{
			rm = connexion.createStatement().executeQuery("SELECT * FROM "+t_table[2]).getMetaData();
			for(int i=1;i<=rm.getColumnCount();i++)
		  	  	if (t_entite[i-1].equals(rm.getColumnLabel(i)))
		  	  		return false;
		}catch (SQLException e){return false;};
		
		//test si la table Episode est correct
		try{
			rm = connexion.createStatement().executeQuery("SELECT * FROM "+t_table[3]).getMetaData();
			for(int i=1;i<=rm.getColumnCount();i++)
		  	  	if (t_episode[i-1].equals(rm.getColumnLabel(i)))
		  	  		return false;
		}catch (SQLException e){return false;};
		
		//test si la table Tome est correct
		try{
			rm = connexion.createStatement().executeQuery("SELECT * FROM "+t_table[4]).getMetaData();
			for(int i=1;i<=rm.getColumnCount();i++)
		  	  	if (t_tome[i-1].equals(rm.getColumnLabel(i)))
		  	  		return false;
		}catch (SQLException e){return false;};
		
		return true;
	}
}
